/**

JSZip - A Javascript class for generating and reading zip files
<http://stuartk.com/jszip>

(c) 2009-2012 Stuart Knightley <stuart [at] stuartk.com>
Dual licenced under the MIT license or GPLv3. See LICENSE.markdown.

Usage:
   zip = new JSZip();
   zip.file("hello.txt", "Hello, World!").add("tempfile", "nothing");
   zip.folder("images").file("smile.gif", base64Data, {base64: true});
   zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")});
   zip.remove("tempfile");

   base64zip = zip.generate();

**/

/**
 * Representation a of zip file in js
 * @constructor
 * @param {String=|ArrayBuffer=|Uint8Array=} data the data to load, if any (optional).
 * @param {Object=} options the options for creating this objects (optional).
 */
var JSZip = function (data, options) {
    // object containing the files :
    // {
    //   "folder/" : {...},
    //   "folder/data.txt" : {...}
    // }
    this.files = {};

    // Where we are in the hierarchy
    this.root = "";

    if (data) {
        this.load(data, options);
    }
};

JSZip.signature = {
    LOCAL_FILE_HEADER: "\x50\x4b\x03\x04",
    CENTRAL_FILE_HEADER: "\x50\x4b\x01\x02",
    CENTRAL_DIRECTORY_END: "\x50\x4b\x05\x06",
    ZIP64_CENTRAL_DIRECTORY_LOCATOR: "\x50\x4b\x06\x07",
    ZIP64_CENTRAL_DIRECTORY_END: "\x50\x4b\x06\x06",
    DATA_DESCRIPTOR: "\x50\x4b\x07\x08"
};

// Default properties for a new file
JSZip.defaults = {
    base64: false,
    binary: false,
    dir: false,
    date: null
};


JSZip.prototype = (function () {
    /**
     * A simple object representing a file in the zip file.
     * @constructor
     * @param {string} name the name of the file
     * @param {string} data the data
     * @param {Object} options the options of the file
     */
    var ZipObject = function (name, data, options) {
        this.name = name;
        this.data = data;
        this.options = options;
    };

    ZipObject.prototype = {
        /**
         * Return the content as UTF8 string.
         * @return {string} the UTF8 string.
         */
        asText: function () {
            var result = this.data;
            if (result === null || typeof result === "undefined") {
                return "";
            }
            if (this.options.base64) {
                result = JSZipBase64.decode(result);
            }
            if (this.options.binary) {
                result = JSZip.prototype.utf8decode(result);
            }
            return result;
        },
        /**
         * Returns the binary content.
         * @return {string} the content as binary.
         */
        asBinary: function () {
            var result = this.data;
            if (result === null || typeof result === "undefined") {
                return "";
            }
            if (this.options.base64) {
                result = JSZipBase64.decode(result);
            }
            if (!this.options.binary) {
                result = JSZip.prototype.utf8encode(result);
            }
            return result;
        },
        /**
         * Returns the content as an Uint8Array.
         * @return {Uint8Array} the content as an Uint8Array.
         */
        asUint8Array: function () {
            return JSZip.utils.string2Uint8Array(this.asBinary());
        },
        /**
         * Returns the content as an ArrayBuffer.
         * @return {ArrayBuffer} the content as an ArrayBufer.
         */
        asArrayBuffer: function () {
            return JSZip.utils.string2Uint8Array(this.asBinary()).buffer;
        }
    };

    /**
     * Transform an integer into a string in hexadecimal.
     * @private
     * @param {number} dec the number to convert.
     * @param {number} bytes the number of bytes to generate.
     * @returns {string} the result.
     */
    var decToHex = function (dec, bytes) {
        var hex = "", i;
        for (i = 0; i < bytes; i++) {
            hex += String.fromCharCode(dec & 0xff);
            dec = dec >>> 8;
        }
        return hex;
    };

    /**
     * Merge the objects passed as parameters into a new one.
     * @private
     * @param {...Object} var_args All objects to merge.
     * @return {Object} a new object with the data of the others.
     */
    var extend = function () {
        var result = {}, i, attr;
        for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
            for (attr in arguments[i]) {
                if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
                    result[attr] = arguments[i][attr];
                }
            }
        }
        return result;
    };

    /**
     * Transforms the (incomplete) options from the user into the complete
     * set of options to create a file.
     * @private
     * @param {Object} o the options from the user.
     * @return {Object} the complete set of options.
     */
    var prepareFileAttrs = function (o) {
        o = o || {};
        if (o.base64 === true && o.binary == null) {
            o.binary = true;
        }
        o = extend(o, JSZip.defaults);
        o.date = o.date || new Date();

        return o;
    };

    /**
     * Add a file in the current folder.
     * @private
     * @param {string} name the name of the file
     * @param {String|ArrayBuffer|Uint8Array} data the data of the file
     * @param {Object} o the options of the file
     * @return {Object} the new file.
     */
    var fileAdd = function (name, data, o) {
        // be sure sub folders exist
        var parent = parentFolder(name);
        if (parent) {
            folderAdd.call(this, parent);
        }

        o = prepareFileAttrs(o);

        if (o.dir || data === null || typeof data === "undefined") {
            o.base64 = false;
            o.binary = false;
            data = null;
        } else if (JSZip.support.uint8array && data instanceof Uint8Array) {
            o.base64 = false;
            o.binary = true;
            data = JSZip.utils.uint8Array2String(data);
        } else if (JSZip.support.arraybuffer && data instanceof ArrayBuffer) {
            o.base64 = false;
            o.binary = true;
            var bufferView = new Uint8Array(data);
            data = JSZip.utils.uint8Array2String(bufferView);
        } else if (o.binary && !o.base64) {
            // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask
            if (o.optimizedBinaryString !== true) {
                // this is a string, not in a base64 format.
                // Be sure that this is a correct "binary string"
                data = JSZip.utils.string2binary(data);
            }
            // we remove this option since it's only relevant here
            delete o.optimizedBinaryString;
        }

        return this.files[name] = new ZipObject(name, data, o);
    };


    /**
     * Find the parent folder of the path.
     * @private
     * @param {string} path the path to use
     * @return {string} the parent folder, or ""
     */
    var parentFolder = function (path) {
        if (path.slice(-1) == '/') {
            path = path.substring(0, path.length - 1);
        }
        var lastSlash = path.lastIndexOf('/');
        return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
    };

    /**
     * Add a (sub) folder in the current folder.
     * @private
     * @param {string} name the folder's name
     * @return {Object} the new folder.
     */
    var folderAdd = function (name) {
        // Check the name ends with a /
        if (name.slice(-1) != "/") {
            name += "/"; // IE doesn't like substr(-1)
        }

        // Does this folder already exist?
        if (!this.files[name]) {
            // be sure sub folders exist
            var parent = parentFolder(name);
            if (parent) {
                folderAdd.call(this, parent);
            }

            fileAdd.call(this, name, null, { dir: true });
        }
        return this.files[name];
    };

    /**
     * Generate the data found in the local header of a zip file.
     * Do not create it now, as some parts are re-used later.
     * @private
     * @param {Object} file the file to use.
     * @param {string} utfEncodedFileName the file name, utf8 encoded.
     * @param {string} compressionType the compression to use.
     * @return {Object} an object containing header and compressedData.
     */
    var prepareLocalHeaderData = function (file, utfEncodedFileName, compressionType) {
        var useUTF8 = utfEncodedFileName !== file.name,
            data = file.asBinary(),
            o = file.options,
            dosTime,
            dosDate;

        // date
        // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
        // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
        // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html

        dosTime = o.date.getHours();
        dosTime = dosTime << 6;
        dosTime = dosTime | o.date.getMinutes();
        dosTime = dosTime << 5;
        dosTime = dosTime | o.date.getSeconds() / 2;

        dosDate = o.date.getFullYear() - 1980;
        dosDate = dosDate << 4;
        dosDate = dosDate | (o.date.getMonth() + 1);
        dosDate = dosDate << 5;
        dosDate = dosDate | o.date.getDate();

        var hasData = data !== null && data.length !== 0;

        var compression = JSZip.compressions[compressionType];
        var compressedData = hasData ? compression.compress(data) : '';

        var header = "";

        // version needed to extract
        header += "\x0A\x00";
        // general purpose bit flag
        // set bit 11 if utf8
        header += useUTF8 ? "\x00\x08" : "\x00\x00";
        // compression method
        header += hasData ? compression.magic : JSZip.compressions['STORE'].magic;
        // last mod file time
        header += decToHex(dosTime, 2);
        // last mod file date
        header += decToHex(dosDate, 2);
        // crc-32
        header += hasData ? decToHex(this.crc32(data), 4) : '\x00\x00\x00\x00';
        // compressed size
        header += hasData ? decToHex(compressedData.length, 4) : '\x00\x00\x00\x00';
        // uncompressed size
        header += hasData ? decToHex(data.length, 4) : '\x00\x00\x00\x00';
        // file name length
        header += decToHex(utfEncodedFileName.length, 2);
        // extra field length
        header += "\x00\x00";

        return {
            header: header,
            compressedData: compressedData
        };
    };


    // return the actual prototype of JSZip
    return {
        /**
         * Read an existing zip and merge the data in the current JSZip object.
         * The implementation is in jszip-load.js, don't forget to include it.
         * @param {String|ArrayBuffer|Uint8Array} stream  The stream to load
         * @param {Object} options Options for loading the stream.
         *  options.base64 : is the stream in base64 ? default : false
         * @return {JSZip} the current JSZip object
         */
        load: function (stream, options) {
            throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
        },

        /**
         * Filter nested files/folders with the specified function.
         * @param {Function} search the predicate to use :
         * function (relativePath, file) {...}
         * It takes 2 arguments : the relative path and the file.
         * @return {Array} An array of matching elements.
         */
        filter: function (search) {
            var result = [], filename, relativePath, file, fileClone;
            for (filename in this.files) {
                if (!this.files.hasOwnProperty(filename)) { continue; }
                file = this.files[filename];
                // return a new object, don't let the user mess with our internal objects :)
                fileClone = new ZipObject(file.name, file.data, extend(file.options));
                relativePath = filename.slice(this.root.length, filename.length);
                if (filename.slice(0, this.root.length) === this.root && // the file is in the current root
                    search(relativePath, fileClone)) { // and the file matches the function
                    result.push(fileClone);
                }
            }
            return result;
        },

        /**
         * Add a file to the zip file, or search a file.
         * @param   {string|RegExp} name The name of the file to add (if data is defined),
         * the name of the file to find (if no data) or a regex to match files.
         * @param   {String|ArrayBuffer|Uint8Array} data  The file data, either raw or base64 encoded
         * @param   {Object} o     File options
         * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
         * a file (when searching by string) or an array of files (when searching by regex).
         */
        file: function (name, data, o) {
            if (arguments.length === 1) {
                if (name instanceof RegExp) {
                    var regexp = name;
                    return this.filter(function (relativePath, file) {
                        return !file.options.dir && regexp.test(relativePath);
                    });
                } else { // text
                    return this.filter(function (relativePath, file) {
                        return !file.options.dir && relativePath === name;
                    })[0] || null;
                }
            } else { // more than one argument : we have data !
                name = this.root + name;
                fileAdd.call(this, name, data, o);
            }
            return this;
        },

        /**
         * Add a directory to the zip file, or search.
         * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
         * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
         */
        folder: function (arg) {
            if (!arg) {
                return this;
            }

            if (arg instanceof RegExp) {
                return this.filter(function (relativePath, file) {
                    return file.options.dir && arg.test(relativePath);
                });
            }

            // else, name is a new folder
            var name = this.root + arg;
            var newFolder = folderAdd.call(this, name);

            // Allow chaining by returning a new object with this folder as the root
            var ret = this.clone();
            ret.root = newFolder.name;
            return ret;
        },

        /**
         * Delete a file, or a directory and all sub-files, from the zip
         * @param {string} name the name of the file to delete
         * @return {JSZip} this JSZip object
         */
        remove: function (name) {
            name = this.root + name;
            var file = this.files[name];
            if (!file) {
                // Look for any folders
                if (name.slice(-1) != "/") {
                    name += "/";
                }
                file = this.files[name];
            }

            if (file) {
                if (!file.options.dir) {
                    // file
                    delete this.files[name];
                } else {
                    // folder
                    var kids = this.filter(function (relativePath, file) {
                        return file.name.slice(0, name.length) === name;
                    });
                    for (var i = 0; i < kids.length; i++) {
                        delete this.files[kids[i].name];
                    }
                }
            }

            return this;
        },

        /**
         * Generate the complete zip file
         * @param {Object} options the options to generate the zip file :
         * - base64, (deprecated, use type instead) true to generate base64.
         * - compression, "STORE" by default.
         * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
         * @return {String|Uint8Array|ArrayBuffer|Blob} the zip file
         */
        generate: function (options) {
            options = extend(options || {}, {
                base64: true,
                compression: "STORE",
                type: "base64"
            });
            var compression = options.compression.toUpperCase();

            // The central directory, and files data
            var directory = [], files = [], fileOffset = 0;

            if (!JSZip.compressions[compression]) {
                throw compression + " is not a valid compression method !";
            }

            for (var name in this.files) {
                if (!this.files.hasOwnProperty(name)) { continue; }

                var file = this.files[name];

                var utfEncodedFileName = this.utf8encode(file.name);

                var fileRecord = "",
                dirRecord = "",
                data = prepareLocalHeaderData.call(this, file, utfEncodedFileName, compression);
                fileRecord = JSZip.signature.LOCAL_FILE_HEADER + data.header + utfEncodedFileName + data.compressedData;

                dirRecord = JSZip.signature.CENTRAL_FILE_HEADER +
                // version made by (00: DOS)
                "\x14\x00" +
                // file header (common to file and central directory)
                data.header +
                // file comment length
                "\x00\x00" +
                // disk number start
                "\x00\x00" +
                // internal file attributes TODO
                "\x00\x00" +
                // external file attributes
                (this.files[name].options.dir === true ? "\x10\x00\x00\x00" : "\x00\x00\x00\x00") +
                // relative offset of local header
                decToHex(fileOffset, 4) +
                // file name
                utfEncodedFileName;

                fileOffset += fileRecord.length;

                files.push(fileRecord);
                directory.push(dirRecord);
            }

            var fileData = files.join("");
            var dirData = directory.join("");

            var dirEnd = "";

            // end of central dir signature
            dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END +
            // number of this disk
            "\x00\x00" +
            // number of the disk with the start of the central directory
            "\x00\x00" +
            // total number of entries in the central directory on this disk
            decToHex(files.length, 2) +
            // total number of entries in the central directory
            decToHex(files.length, 2) +
            // size of the central directory   4 bytes
            decToHex(dirData.length, 4) +
            // offset of start of central directory with respect to the starting disk number
            decToHex(fileData.length, 4) +
            // .ZIP file comment length
            "\x00\x00";

            var zip = fileData + dirData + dirEnd;


            switch (options.type.toLowerCase()) {
                case "uint8array":
                    return JSZip.utils.string2Uint8Array(zip);
                case "arraybuffer":
                    return JSZip.utils.string2Uint8Array(zip).buffer;
                case "blob":
                    return JSZip.utils.string2Blob(zip);
                case "base64":
                    return (options.base64) ? JSZipBase64.encode(zip) : zip;
                default: // case "string" :
                    return zip;
            }
        },

        /**
         *
         *  Javascript crc32
         *  http://www.webtoolkit.info/
         *
         */
        crc32: function (str, crc) {

            if (str === "" || typeof str === "undefined") {
                return 0;
            }

            var table = [
               0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
               0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
               0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
               0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
               0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
               0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
               0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
               0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
               0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
               0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
               0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
               0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
               0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
               0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
               0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
               0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
               0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
               0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
               0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
               0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
               0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
               0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
               0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
               0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
               0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
               0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
               0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
               0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
               0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
               0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
               0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
               0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
               0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
               0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
               0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
               0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
               0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
               0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
               0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
               0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
               0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
               0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
               0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
               0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
               0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
               0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
               0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
               0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
               0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
               0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
               0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
               0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
               0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
               0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
               0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
               0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
               0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
               0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
               0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
               0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
               0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
               0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
               0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
               0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
            ];

            if (typeof (crc) == "undefined") { crc = 0; }
            var x = 0;
            var y = 0;

            crc = crc ^ (-1);
            for (var i = 0, iTop = str.length; i < iTop; i++) {
                y = (crc ^ str.charCodeAt(i)) & 0xFF;
                x = table[y];
                crc = (crc >>> 8) ^ x;
            }

            return crc ^ (-1);
        },

        // Inspired by http://my.opera.com/GreyWyvern/blog/show.dml/1725165
        clone: function () {
            var newObj = new JSZip();
            for (var i in this) {
                if (typeof this[i] !== "function") {
                    newObj[i] = this[i];
                }
            }
            return newObj;
        },


        /**
         * http://www.webtoolkit.info/javascript-utf8.html
         */
        utf8encode: function (string) {
            string = string.replace(/\r\n/g, "\n");
            var utftext = "";

            for (var n = 0; n < string.length; n++) {

                var c = string.charCodeAt(n);

                if (c < 128) {
                    utftext += String.fromCharCode(c);
                } else if ((c > 127) && (c < 2048)) {
                    utftext += String.fromCharCode((c >> 6) | 192);
                    utftext += String.fromCharCode((c & 63) | 128);
                } else {
                    utftext += String.fromCharCode((c >> 12) | 224);
                    utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                    utftext += String.fromCharCode((c & 63) | 128);
                }

            }

            return utftext;
        },

        /**
         * http://www.webtoolkit.info/javascript-utf8.html
         */
        utf8decode: function (utftext) {
            var string = "";
            var i = 0;
            var c = 0, c1 = 0, c2 = 0, c3 = 0;

            while (i < utftext.length) {

                c = utftext.charCodeAt(i);

                if (c < 128) {
                    string += String.fromCharCode(c);
                    i++;
                } else if ((c > 191) && (c < 224)) {
                    c2 = utftext.charCodeAt(i + 1);
                    string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                    i += 2;
                } else {
                    c2 = utftext.charCodeAt(i + 1);
                    c3 = utftext.charCodeAt(i + 2);
                    string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                    i += 3;
                }

            }

            return string;
        }
    };
}());

/*
 * Compression methods
 * This object is filled in as follow :
 * name : {
 *    magic // the 2 bytes indentifying the compression method
 *    compress // function, take the uncompressed content and return it compressed.
 *    uncompress // function, take the compressed content and return it uncompressed.
 * }
 *
 * STORE is the default compression method, so it's included in this file.
 * Other methods should go to separated files : the user wants modularity.
 */
JSZip.compressions = {
    "STORE": {
        magic: "\x00\x00",
        compress: function (content) {
            return content; // no compression
        },
        uncompress: function (content) {
            return content; // no compression
        }
    }
};

/*
 * List features that require a modern browser, and if the current browser support them.
 */
JSZip.support = {
    // contains true if JSZip can read/generate ArrayBuffer, false otherwise.
    arraybuffer: (function () {
        return typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
    })(),
    // contains true if JSZip can read/generate Uint8Array, false otherwise.
    uint8array: (function () {
        return typeof Uint8Array !== "undefined";
    })(),
    // contains true if JSZip can read/generate Blob, false otherwise.
    blob: (function () {
        // the spec started with BlobBuilder then replaced it with a construtor for Blob.
        // Result : we have browsers that :
        // * know the BlobBuilder (but with prefix)
        // * know the Blob constructor
        // * know about Blob but not about how to build them
        // About the "=== 0" test : if given the wrong type, it may be converted to a string.
        // Instead of an empty content, we will get "[object Uint8Array]" for example.
        if (typeof ArrayBuffer === "undefined") {
            return false;
        }
        var buffer = new ArrayBuffer(0);
        try {
            return new Blob([buffer], { type: "application/zip" }).size === 0;
        }
        catch (e) { }

        try {
            var builder = new (window.BlobBuilder || window.WebKitBlobBuilder ||
                               window.MozBlobBuilder || window.MSBlobBuilder)();
            builder.append(buffer);
            return builder.getBlob('application/zip').size === 0;
        }
        catch (e) { }

        return false;
    })()
};

JSZip.utils = {
    /**
     * Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
     * @param {string} str the string to transform.
     * @return {String} the binary string.
     */
    string2binary: function (str) {
        var result = "";
        for (var i = 0; i < str.length; i++) {
            result += String.fromCharCode(str.charCodeAt(i) & 0xff);
        }
        return result;
    },
    /**
     * Create a Uint8Array from the string.
     * @param {string} str the string to transform.
     * @return {Uint8Array} the typed array.
     * @throws {Error} an Error if the browser doesn't support the requested feature.
     */
    string2Uint8Array: function (str) {
        if (!JSZip.support.uint8array) {
            throw new Error("Uint8Array is not supported by this browser");
        }
        var buffer = new ArrayBuffer(str.length);
        var bufferView = new Uint8Array(buffer);
        for (var i = 0; i < str.length; i++) {
            bufferView[i] = str.charCodeAt(i);
        }

        return bufferView;
    },

    /**
     * Create a string from the Uint8Array.
     * @param {Uint8Array} array the array to transform.
     * @return {string} the string.
     * @throws {Error} an Error if the browser doesn't support the requested feature.
     */
    uint8Array2String: function (array) {
        if (!JSZip.support.uint8array) {
            throw new Error("Uint8Array is not supported by this browser");
        }
        var result = "";
        for (var i = 0; i < array.length; i++) {
            result += String.fromCharCode(array[i]);
        }

        return result;
    },
    /**
     * Create a blob from the given string.
     * @param {string} str the string to transform.
     * @return {Blob} the string.
     * @throws {Error} an Error if the browser doesn't support the requested feature.
     */
    string2Blob: function (str) {
        if (!JSZip.support.blob) {
            throw new Error("Blob is not supported by this browser");
        }

        var buffer = JSZip.utils.string2Uint8Array(str).buffer;
        try {
            // Blob constructor
            return new Blob([buffer], { type: "application/zip" });
        }
        catch (e) { }

        try {
            // deprecated, browser only, old way
            var builder = new (window.BlobBuilder || window.WebKitBlobBuilder ||
                               window.MozBlobBuilder || window.MSBlobBuilder)();
            builder.append(buffer);
            return builder.getBlob('application/zip');
        }
        catch (e) { }

        // well, fuck ?!
        throw new Error("Bug : can't construct the Blob.");
    }
};

/**
 *
 *  Base64 encode / decode
 *  http://www.webtoolkit.info/
 *
 *  Hacked so that it doesn't utf8 en/decode everything
 **/
var JSZipBase64 = (function () {
    // private property
    var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

    return {
        // public method for encoding
        encode: function (input, utf8) {
            var output = "";
            var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
            var i = 0;

            while (i < input.length) {

                chr1 = input.charCodeAt(i++);
                chr2 = input.charCodeAt(i++);
                chr3 = input.charCodeAt(i++);

                enc1 = chr1 >> 2;
                enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
                enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
                enc4 = chr3 & 63;

                if (isNaN(chr2)) {
                    enc3 = enc4 = 64;
                } else if (isNaN(chr3)) {
                    enc4 = 64;
                }

                output = output +
                   _keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
                   _keyStr.charAt(enc3) + _keyStr.charAt(enc4);

            }

            return output;
        },

        // public method for decoding
        decode: function (input, utf8) {
            var output = "";
            var chr1, chr2, chr3;
            var enc1, enc2, enc3, enc4;
            var i = 0;

            input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

            while (i < input.length) {

                enc1 = _keyStr.indexOf(input.charAt(i++));
                enc2 = _keyStr.indexOf(input.charAt(i++));
                enc3 = _keyStr.indexOf(input.charAt(i++));
                enc4 = _keyStr.indexOf(input.charAt(i++));

                chr1 = (enc1 << 2) | (enc2 >> 4);
                chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
                chr3 = ((enc3 & 3) << 6) | enc4;

                output = output + String.fromCharCode(chr1);

                if (enc3 != 64) {
                    output = output + String.fromCharCode(chr2);
                }
                if (enc4 != 64) {
                    output = output + String.fromCharCode(chr3);
                }

            }

            return output;

        }
    };
}());

// enforcing Stuk's coding style
// vim: set shiftwidth=3 softtabstop=3: